package models.proxies {
  import com.axon.base.helpers.AxFailure;
  import com.axon.base.managers.AxErrorManager;
  import com.axon.dataservices.AxDS;
  import com.axon.mvc.helpers.AxVerbs;
  import com.axon.mvc.patterns.proxy.AxProxy;

  import helpers.Constants;
  import helpers.ListaPleitos;
  import helpers.Verbs;

  import models.vo.Pleito;

  import org.restfulx.collections.ModelsCollection;

  public class PleitoProxy extends AxProxy {

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    [Bindable]
    public var listaTriagem:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_TRIAGEM);

    [Bindable]
    public var listaAnalise:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_ANALISE);

    [Bindable]
    public var listaDistribuicao:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_DISTRIBUICAO);

    [Bindable]
    public var listaCertificacao:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_CERTIFICACAO);

    [Bindable]
    public var listaRecomendacao:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_RECOMENDACAO);

    [Bindable]
    public var listaDeliberacao:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_DELIBERACAO);

    [Bindable]
    public var listaAprovados:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_APROVADOS);

    [Bindable]
    public var listaArquivados:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_ARQUIVADOS);

    [Bindable]
    public var listaRejeitados:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_REJEITADOS);

    [Bindable]
    public var listaConsulta:ListaPleitos = new ListaPleitos(Constants.MNEMONICO_LISTA_CONSULTA);

    public var listaSendoCarregada:ListaPleitos;

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    private function listaComMnemonico(mnemonico:String):ListaPleitos {
      var lista:ListaPleitos = null;

      switch (mnemonico) {
        case Constants.MNEMONICO_LISTA_TRIAGEM:
          lista = listaTriagem;
          break;
        case Constants.MNEMONICO_LISTA_ANALISE:
          lista = listaAnalise;
          break;
        case Constants.MNEMONICO_LISTA_DISTRIBUICAO:
          lista = listaDistribuicao;
          break;
        case Constants.MNEMONICO_LISTA_CERTIFICACAO:
          lista = listaCertificacao;
          break;
        case Constants.MNEMONICO_LISTA_RECOMENDACAO:
          lista = listaRecomendacao;
          break;
        case Constants.MNEMONICO_LISTA_DELIBERACAO:
          lista = listaDeliberacao;
          break;
        case Constants.MNEMONICO_LISTA_APROVADOS:
          lista = listaAprovados;
          break;
        case Constants.MNEMONICO_LISTA_ARQUIVADOS:
          lista = listaArquivados;
          break;
        case Constants.MNEMONICO_LISTA_REJEITADOS:
          lista = listaRejeitados;
          break;
        case Constants.MNEMONICO_LISTA_CONSULTA:
          lista = listaConsulta;
          break;
      }
      return lista;
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function list(mnemonicoLista:String, search:Object = null):void {
      listaSendoCarregada = listaComMnemonico(mnemonicoLista);

      if (!listaSendoCarregada.needRefresh) {
        reportSuccess(AxVerbs.LIST, listaSendoCarregada);
        return;
      }

      if (listaSendoCarregada.mnemonico == Constants.MNEMONICO_LISTA_ANALISE) {

        AxDS.httpInvoke(onListSuccess, onListFailure, "analistas/" + AppFacade(facade).sessionProxy.user.id + "/pleitos_em_analise.fxml",
          null, AxDS.GET, true);
      }

      else if (listaSendoCarregada.mnemonico == Constants.MNEMONICO_LISTA_CONSULTA) {
        AxDS.httpInvoke(onListSuccess, onListFailure, "pleitos.fxml", search, AxDS.GET, true);
      }

      else {

        AxDS.httpInvoke(onListSuccess, onListFailure, "pleitos.fxml", {status: listaSendoCarregada.filtro.paramToLoadCall()},
          AxDS.GET, true);

//              TODO - Estava dando erro depois da migração para o RestfulX 1.2.3

//				AxDS.reload( Pleito, onListSuccess, onListFailure, 
//					null, { status: listaSendoCarregada.filtro.paramToLoadCall() }, false);
      }
    }

    private function onListSuccess(result:Object):void {
      listaSendoCarregada.modelsCollection = new ModelsCollection(result as Array);
      listaSendoCarregada.needRefresh = false;

      reportSuccess(AxVerbs.LIST, listaSendoCarregada);
    }

    private function onListFailure(result:Object):void {
      reportFailure(AxVerbs.LIST);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function read(pleito:Pleito):void {
      AxDS.httpInvoke(onReadSuccess, onReadFailure, "pleitos/" + pleito.id, null, AxDS.GET, true);
    }

    private function onReadSuccess(result:Pleito):void {
      reportSuccess(AxVerbs.READ, result);
    }

    private function onReadFailure(result:Object):void {
      reportFailure(AxVerbs.READ);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function registrarProtocolo(pleito:Pleito):void {
      AxDS.httpInvoke(onRegistrarProtocoloSuccess, onRegistrarProtocoloFailure, "pleitos/" + pleito.id + "/registrar_protocolo",
        {numero_protocolo: pleito.numeroProtocolo, data_protocolo: pleito.dataProtocolo}, AxDS.PUT, true);
    }

    private function onRegistrarProtocoloSuccess(result:Pleito):void {
      reportSuccess(Verbs.REGISTRAR_PROTOCOLO, result);
    }

    private function onRegistrarProtocoloFailure(result:Object):void {
      reportFailure(Verbs.REGISTRAR_PROTOCOLO);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function registrarDoctosAdic(pleito:Pleito):void {
      AxDS.httpInvoke(onRegistrarDoctosAdicSuccess, onRegistrarDoctosAdicFailure, "pleitos/" + pleito.id + "/registrar_documentos_adicionais",
        {documentos_adicionais: pleito.documentosAdicionais}, AxDS.PUT, true);
    }

    private function onRegistrarDoctosAdicSuccess(result:Pleito):void {
      reportSuccess(Verbs.REGISTRAR_DOCTOS_ADIC, result);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    private function onRegistrarDoctosAdicFailure(result:Object):void {
      reportFailure(Verbs.REGISTRAR_DOCTOS_ADIC);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function aceitarInscricao(pleito:Pleito):void {
      AxDS.httpInvoke(onAceitarInscricaoSuccess, onAceitarInscricaoFailure, "pleitos/" + pleito.id + "/aceitar_inscricao",
        {numero_processo: pleito.numeroProcesso, codigo_arquivo: pleito.codigoArquivo, data_processo: pleito.dataProcesso, complemento1: pleito.getTramitacao(Constants.STATUS_PLEITO_DISTRIBUICAO).complemento1},
        AxDS.PUT, true);
    }

    private function onAceitarInscricaoSuccess(result:Pleito):void {
      if (result.status == "DocVencida") {
        AxErrorManager.showFailure(new AxFailure("Documentação vencida. Esse pleito não pode ser aceito."));
      } else {
        listaDistribuicao.invalidate();
        reportSuccess(Verbs.ACEITAR_INSCRICAO, result);
      }
    }

    private function onAceitarInscricaoFailure(result:Object):void {
      reportFailure(Verbs.ACEITAR_INSCRICAO);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function rejeitarInscricao(pleito:Pleito):void {
      AxDS.httpInvoke(onRejeitarInscricaoSuccess, onRejeitarInscricaoFailure, "pleitos/" + pleito.id + "/rejeitar_inscricao",
        {complemento1: pleito.getTramitacao(Constants.STATUS_PLEITO_REJEITADO).complemento1, complemento2: pleito.getTramitacao(Constants.STATUS_PLEITO_REJEITADO).complemento2},
        AxDS.PUT, true);
    }

    private function onRejeitarInscricaoSuccess(result:Pleito):void {
      listaRejeitados.invalidate();
      reportSuccess(Verbs.REJEITAR_INSCRICAO, result);
    }

    private function onRejeitarInscricaoFailure(result:Object):void {
      reportFailure(Verbs.REJEITAR_INSCRICAO);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function distribuir(pleito:Pleito):void {
      var params:Object = (pleito.analise.getAnalista2().id == "") ? {analista_1_id: pleito.analise.getAnalista1().id} : {analista_1_id: pleito.analise.getAnalista1().id, analista_2_id: pleito.analise.getAnalista2().id};

      AxDS.httpInvoke(onDistribuirSuccess, onDistribuirFailure, "pleitos/" + pleito.id + "/distribuir", params, AxDS.PUT,
        true);
    }

    private function onDistribuirSuccess(result:Pleito):void {
      listaAnalise.invalidate();
      reportSuccess(Verbs.DISTRIBUIR, result);
    }

    private function onDistribuirFailure(result:Object):void {
      reportFailure(Verbs.DISTRIBUIR);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function avancar(pleito:Pleito, extraInfo:Object):void {
      var action:String;

      switch (pleito.status) {
        case Constants.STATUS_PLEITO_ANALISE:
          action = 'encaminhar_para_certificacao';
          break;
        case Constants.STATUS_PLEITO_CERTIFICACAO:
          action = 'encaminhar_para_recomendacao';
          break;
        case Constants.STATUS_PLEITO_RECOMENDACAO:
          action = 'encaminhar_para_deliberacao';
          break;
        case Constants.STATUS_PLEITO_DELIBERACAO:
          action = 'aprovar';
          break;
      }

      AxDS.httpInvoke(onAvancarSuccess, onAvancarFailure, "pleitos/" + pleito.id + "/" + action, {texto: extraInfo.texto, data: extraInfo.data, numero: extraInfo.numero},
        AxDS.PUT, true);
    }

    private function onAvancarSuccess(result:Pleito):void {
      switch (result.status) {
        case Constants.STATUS_PLEITO_CERTIFICACAO:
          listaCertificacao.invalidate();
          break;
        case Constants.STATUS_PLEITO_RECOMENDACAO:
          listaRecomendacao.invalidate();
          break;
        case Constants.STATUS_PLEITO_DELIBERACAO:
          listaDeliberacao.invalidate();
          break;
      }

      reportSuccess(Verbs.AVANCAR, result);
    }

    private function onAvancarFailure(result:Object):void {
      reportFailure(Verbs.AVANCAR);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function aprovar(pleito:Pleito, extraInfo:Object):void {
      AxDS.httpInvoke(onAprovarSuccess, onAprovarFailure, "pleitos/" + pleito.id + "/aprovar", {texto: extraInfo.texto},
        AxDS.PUT, true);
    }

    private function onAprovarSuccess(result:Pleito):void {
      listaAprovados.invalidate();
      reportSuccess(Verbs.AVANCAR, result);
    }

    private function onAprovarFailure(result:Object):void {
      reportFailure(Verbs.AVANCAR);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function voltarParaAnalise(pleito:Pleito, extraInfo:Object):void {
      AxDS.httpInvoke(onVoltarParaAnaliseSuccess, onVoltarParaAnaliseFailure, "pleitos/" + pleito.id + "/voltar_para_analise",
        {texto: extraInfo.texto}, AxDS.PUT, true);
    }

    private function onVoltarParaAnaliseSuccess(result:Pleito):void {
      listaAnalise.invalidate();
      reportSuccess(Verbs.VOLTAR_PARA_ANALISE, result);
    }

    private function onVoltarParaAnaliseFailure(result:Object):void {
      reportFailure(Verbs.VOLTAR_PARA_ANALISE);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function arquivar(pleito:Pleito, extraInfo:Object):void {
      AxDS.httpInvoke(onArquivarSuccess, onArquivarFailure, "pleitos/" + pleito.id + "/arquivar", {texto: extraInfo.texto},
        AxDS.PUT, true);
    }

    private function onArquivarSuccess(result:Pleito):void {
      listaArquivados.invalidate();
      reportSuccess(Verbs.ARQUIVAR, result);
    }

    private function onArquivarFailure(result:Object):void {
      reportFailure(Verbs.ARQUIVAR);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function editarDataLaudo(pleito:Pleito, novosDados:Object):void {
      var action:String = "";
      var tipo:String = novosDados.tipo;
      switch (tipo) {
        case "relatPortariaMinuta":
        case "relatPortariaVersaoFinal":
          action = "modificar_data_portaria";
          break;
        case "relatLaudoMinuta":
        case "relatLaudoVersaoFinal":
          action = "modificar_data_laudo";
          break;
        case "relatOficioEmpresa":
          action = "modificar_data_oficio_empresa";
          break;
        case "relatOficioEmpresaLiberacao":
          action = "modificar_data_oficio_empresa_liberacao";
          break;
        case "relatOficioReceita":
          action = "modificar_data_oficio_receita";
          break;
        case "relatOficioBnb":
          action = "modificar_data_oficio_bnb";
          break;
        case "relatOficioMarinha":
          action = "modificar_data_oficio_marinha";
          break;
      }
      AxDS.httpInvoke(onEditarDataLaudoSuccess, onEditarDataLaudoFailure, "pleitos/" + pleito.id + "/" + action,
        {data: novosDados.data, numero: novosDados.numero}, AxDS.PUT, true);
    }

    private function onEditarDataLaudoSuccess(result:Pleito):void {
      reportSuccess(Verbs.EDITAR_DATA_LAUDO, result);
    }

    private function onEditarDataLaudoFailure(result:Object):void {
      reportFailure(Verbs.EDITAR_DATA_LAUDO);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    public function invalidarTodasAsListas():void {
      listaAprovados.invalidate();
      listaArquivados.invalidate();
      listaCertificacao.invalidate();
      listaDeliberacao.invalidate();
      listaDistribuicao.invalidate();
      listaRecomendacao.invalidate();
      listaRejeitados.invalidate();
      listaTriagem.invalidate();
    }
  }
}